//---------------------------------------------------------------------------

#include <vcl.h>
#include <registry.hpp>
#include <utilcls.h>
#include <Printers.hpp>

#include <tlhelp32.h>
#pragma hdrstop

#include <eic.h>
#include "EnvoiGED.h"
#include "uEnvoiGED.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)
#define MODULE_TAG 2


#define NomPiloteGED         "GEDEIC"
#define NomPiloteGEDPaniere  "GEDEICPaniere"
#define NomPiloteGED2        "NOVAXEL"
#define NomPiloteGEDPaniere2 "Novapaniere"
#define NomProcessusGED      "novaxel.exe"

#define Defaut_cap_ImpDef  "imprimantePardefaut"
#define Defaut_cap_Section "PDF"

bool IsProcessusEnCours(char *szNomProcessus);

//---------------------------------------------------------------------------
bool    GED_gGestionEnvoi = true;
char    GED_szCleRegLog[250] = Defaut_RegCleLog;

CGEDGlobal *GEDGlobal;

int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void*)
{
    switch( reason)
    {   case DLL_PROCESS_ATTACH :
            try{
                GEDGlobal = new CGEDGlobal();
                memset( GEDGlobal, 0, sizeof( *GEDGlobal));
                AnsiString fDefaut_cap = IncludeTrailingBackslash( AnsiString( getenv( "USERPROFILE"))) + "Novaxel\\Defaut.cap";
                if( FileExists( fDefaut_cap))
                {
                  TIniFile *Defaut_cap = new TIniFile( fDefaut_cap);
                  if( Defaut_cap->ReadBool( Defaut_cap_Section, Defaut_cap_ImpDef, true) == true)
                    GEDGlobal->pFileDefautCap = (void*)Defaut_cap;
                }
                GEDGlobal->bClassAuto = ::GetModuleHandle( "MENUFED.EXE");
                GEDGlobal->bCapture = false;
            }catch( Exception &e)
            {
              EICDisplayException(TAGL, e);
            }
            break;
        case DLL_PROCESS_DETACH :
            try{
                if( GEDGlobal->pFileDefautCap) delete (TIniFile*)GEDGlobal->pFileDefautCap;
                ASSERT( GEDGlobal->nOLEInitialise == 0);
                delete GEDGlobal;
                GEDGlobal = NULL;
            }catch( Exception &e)
            {
              EICDisplayException(TAGL, e);
            }
            break;
    }
    return 1;
}

//---------------------------------------------------------------------------
bool __stdcall GED_Ouvre(       long &pvGedEIC)
{ pvGedEIC =  (long) new Variant;
  return GED_Ouvre( (Variant*)pvGedEIC);}

bool __stdcall GED_Ferme(       long &pvGedEIC)
{ bool b = GED_Ferme( (Variant*)pvGedEIC);
  delete (Variant*)pvGedEIC; pvGedEIC = 0L;
  return b;
}

bool __stdcall GED_DebutDocument(long pvGedEIC, const char* Classement, int &DestGED, const char *NomDocument, char *szNomImprimante, int LenNomImprimante)
{
  AnsiString NomImprimante = szNomImprimante;
  bool bReturn = GED_DebutDocument( (Variant*)pvGedEIC, Classement, DestGED, NomDocument, NomImprimante);
  strncpy( szNomImprimante, NomImprimante.c_str(), LenNomImprimante-1);
  return bReturn;
}

bool __stdcall GED_FinDocument(long pvGedEIC)
{ return GED_FinDocument( (Variant*)pvGedEIC);}
//---------------------------------------------------------------------------

#define ChkOLE( Tag, cond)    { int nRet = cond; if( nRet != S_OK) {SetLastError( nRet); AfficheLastErrorT( AnsiString("TAG[")+TAG_MODULE( Tag)+"-"+ TAG_TAG( Tag)+"] "+ #cond);}}
void OLEInitialize()
{
    if( !GEDGlobal->nOLEInitialise)
    {
        HRESULT h = OleInitialize(NULL);
        if( h != S_FALSE) ChkOLE( TAGL, h);
    }
    GEDGlobal->nOLEInitialise++;
}
void OLEUnInitialize()
{
  if (GEDGlobal->nOLEInitialise)
    GEDGlobal->nOLEInitialise--;
    if( !GEDGlobal->nOLEInitialise)
        OleUninitialize();
}
//---------------------------------------------------------------------------
AnsiString __fastcall GED_NomPilote()
{
  if( Printer()->Printers->IndexOf(NomPiloteGED) == -1)
    return NomPiloteGED2;
  return NomPiloteGED;
}
AnsiString __fastcall GED_NomPilotePaniere()
{
  if( Printer()->Printers->IndexOf(NomPiloteGEDPaniere) == -1)
    return NomPiloteGEDPaniere2;
  return NomPiloteGEDPaniere;
}
bool __fastcall GED_IsPrinterGED( const AnsiString & PrinterName)
{
  return ((PrinterName == GED_NomPilote()) || (PrinterName == GED_NomPilotePaniere()));
}
//---------------------------------------------------------------------------
bool __fastcall CreationObjetGED( Variant *pvGedEIC)
{
  ASSERT( GEDGlobal->nOLEInitialise > 0);
  try{
    *pvGedEIC = Variant::CreateObject( "Novaxel.NovaxelSQL");
  }catch( EOleSysError &e){
    *pvGedEIC = Unassigned;
    return false;
  }
  return true;
}

bool __fastcall GED_IsInstallee()
{
  if( !GED_gGestionEnvoi) return false;
  Variant vGedEIC;
  bool bGEDEICInstalle;
  OLEInitialize();

  bGEDEICInstalle = CreationObjetGED( &vGedEIC);
  vGedEIC = Unassigned;

  OLEUnInitialize();
  return bGEDEICInstalle;
}

bool GEDAPI __fastcall GED_IsClassAuto()
{
  return GEDGlobal->bClassAuto;
}

int _NbColonnes=0;
void GEDAPI __stdcall GED_InitColonnes(int pNombreColonnes)
{
  _NbColonnes = pNombreColonnes;
}

bool __fastcall GED_Ouvre(Variant *pvGedEIC,bool bEicReessayer)
{                                                                                                         
  bool bGED = false;
  OLEInitialize();
  do{
    try{
      if( CreationObjetGED( pvGedEIC))
      {
//                vGedEIC.OleFunction( "Ouvre", WideString(Glob->CheminBaseGED), WideString(), WideString(), true);
        WideString EmptyWtr;
        Variant v = pvGedEIC->OleFunction( "GetItemsOfBranche", EmptyWtr, EmptyWtr,EmptyWtr,EmptyWtr);
        bGED = true;
      }else break;
    }catch(...)
    {
      *pvGedEIC = Unassigned;
      bGED = false;
      if (bEicReessayer){
          if (!EICReessayer("Veuillez lancer "NomAppliGED" avant d'envoyer un document.","Attention..."))
            break;
      }else
          break;
    }

  }while( !bGED);
  if( !bGED) OLEUnInitialize();
  else
  {//On vérifie que l'on a bien le même nombre de colonnes
   if (bEicReessayer && _NbColonnes != (int)pvGedEIC->OlePropertyGet("ColonneCount"))
    {        
      EICAttention("Le nombre de colonnes paramétré dans "NomAppliGED" est différent de celui du modèle du dossier.");
      bGED = false;
      OLEUnInitialize();
    }
  }

  return bGED;
}

bool __fastcall GED_Ferme(Variant *pvGedEIC)
{
  if( !VarIsEmpty(*pvGedEIC))
  {
    *pvGedEIC = Unassigned;
    OLEUnInitialize();
  }
  return true;
}

AnsiString GEDAPI __fastcall GED_DonnerDocumentSelectionne(Variant *pvGedEIC)
{
  TStringList *Chemin = NULL;
  bool bGED = false,Trouve = false;
  AnsiString Image;
  OLEInitialize();
  do
    {
      try
        {
          if (CreationObjetGED(pvGedEIC))
            {
              int NbColonnes = (int)pvGedEIC->OlePropertyGet("ColonneCount");
              Chemin = new TStringList();
              for (int i = 1;i <= NbColonnes;i++)
                Chemin->Add(AnsiString(pvGedEIC->OleFunction("FgetCriteres",i)));
              NbColonnes = (int)pvGedEIC->OlePropertyGet("ActiveChemise");
              if (NbColonnes != -1)
                Chemin->Add("[" + AnsiString(pvGedEIC->OlePropertyGet("TitreChemise",NbColonnes)) + "]");
              NbColonnes = (int)pvGedEIC->OlePropertyGet("PageCount");
              for (int i = 0;i < NbColonnes;i++)
                if ((bool)pvGedEIC->OlePropertyGet("SelectPage",i))
                  {
                    Chemin->Add(AnsiString(pvGedEIC->OleFunction("FgetTitrePage",i)));
                    Trouve = true;
                    break;
                  }
              if (Trouve)
                Image = Chemin->CommaText;
              else
                EICAttention("Aucun document n'est sélectionné dans GED'EIC.\nVeuillez sélectionner un document et recommencer l'opération.");
              delete Chemin;
              Chemin = NULL;
              bGED = true;
            }
          else
            break;
        }
      catch(...)
        {
          *pvGedEIC = Unassigned;
          delete Chemin;
          Chemin = NULL;
          if (!EICReessayer("Veuillez lancer " NomAppliGED " pour sélectionner un document.","Attention..."))
            return EmptyStr;
        }
    }
  while (!bGED);
  OLEUnInitialize();
  return Image;
}



bool __fastcall GED_AfficherDocument(Variant *pvGedEIC,const AnsiString &Image)
{
  int NbColonnes;
  bool Trouve = false;
  TStringList *Chemin = NULL;
  AnsiString NomDocument,Arborescence,Chemise;
  OLEInitialize();
  try
    {
      if( CreationObjetGED( pvGedEIC))
      {
        Chemin = new TStringList();
        Chemin->CommaText = Image;
        if (Chemin->Count < 2)
          {
            EICAttention("Le chemin associé n'est pas valide.\nAffichage du document impossible.");
            return false;
          }
        NomDocument = Chemin->Strings[Chemin->Count - 1];  //Le nom du document est le dernier du chemin
        Chemin->Delete(Chemin->Count - 1);  //On retire le nom du document du chemin
        Chemise = Chemin->Strings[Chemin->Count - 1];  //S'il ya une chemise elle est placée en dernier dans le chemin restant
        if (!Chemise.IsEmpty() && (Chemise[1] == '['))
          {//Il y a une chemise
            Chemise = Chemise.SubString(2,Chemise.Length() - 2);  //On retire les crochets
            Chemin->Delete(Chemin->Count - 1);  //On retire la chemise du chemin
          }
        else
          {//Il n'y a pas de chemise
            Chemise = EmptyStr;
          }
        for (int i = 0;i < Chemin->Count;i++)
          Arborescence = Arborescence + Chemin->Strings[i] + "/";
        Arborescence.Delete(Arborescence.Length(),1);
        //if ((bool)pvGedEIC->OleFunction("TrouveDossier",WideString(Chemin->CommaText)))
        //On remplace TrouveDossier par FindDossier car si on est dans la mauvaise bibliothèque TrouveDossier crée l'arborescence dans cette bibliothèque
        int numeroDossier = 0;
        numeroDossier = pvGedEIC->OleFunction("FindDossier",WideString(Chemin->CommaText));
        if (numeroDossier >0)
          {//On a trouvé le bon dossier
            //On commence par afficher le dossier en cours
            pvGedEIC->OleFunction("AfficheDossierEncours",true);
            //On charge le bon dossier
            if ((bool)pvGedEIC->OleFunction("ChargeDossierNum",numeroDossier))
            {
              //On a pu afficher le bon dossier
              //pvGedEIC->OleFunction("AfficheBibliotheque");
              if (!Chemise.IsEmpty())
                {//Il y a une chemise, on doit sélectionner la bonne chemise
                  NbColonnes = (int)pvGedEIC->OlePropertyGet("ChemiseCount");
                  for (int i = 0;i < NbColonnes;i++)
                    if (AnsiSameText(Chemise,AnsiString(pvGedEIC->OlePropertyGet("TitreChemise",i))))
                      {
                        Trouve = true;
                        pvGedEIC->OlePropertySet("ActiveChemise",i);
                        break;
                      }
                  if (!Trouve)
                    {
                      EICAttention(EICFormat("Impossible de trouver la chemise '%s'\ndans l'arborescence '%s'.\n\nVeillez à ce que la bonne bibliothèque soit ouverte.",Chemise.c_str(),Arborescence.c_str()));
                      return false;
                    }
                }
              Trouve = false;
              //if ((bool)pvGedEIC->OleFunction("AfficheDossierEncours",true))
                //{On a pu afficher le bon dossier
                  NbColonnes = (int)pvGedEIC->OlePropertyGet("PageCount");
                  for (int i = 0;i < NbColonnes;i++)
                    if (AnsiSameText(NomDocument,AnsiString(pvGedEIC->OleFunction("FgetTitrePage",i))) && (bool)pvGedEIC->OleFunction("AffichePage",i))
                      {//On a trouvé le bon document
                        Trouve = true;
                        break;
                      }
                  if (Trouve)
                    return true;
                  else
                    {
                      EICAttention(EICFormat("Impossible de trouver le document '%s'\ndans l'arborescence '%s'.",NomDocument.c_str(),Arborescence.c_str()));
                      return false;
                    }
               // }
              }
              else
              {
                EICAttention(EICFormat("Impossible d'afficher l'arborescence '%s'.",Arborescence.c_str()));
                return false;
              }
          }
        else
          {
            EICAttention(EICFormat("Impossible de trouver l'arborescence '%s'.\n\nVérifiez que la bonne bibliothèque soit ouverte.",Arborescence.c_str()));
            return false;
          }
      }
    }
  catch(...)
    {
      *pvGedEIC = Unassigned;
      EICReessayer("Veuillez lancer " NomAppliGED " pour afficher le document.","Attention...");
    }
  return false;
}
//---------------------------------------------------------------------------
void __fastcall GED_Capture( Variant *pvGedEIC, int &DestGED)
{
    if( GEDGlobal->bCapture) return;
    TIniFile *Defaut_cap = (TIniFile *)GEDGlobal->pFileDefautCap;

    if( DestGED==1)
    {
      try{
        pvGedEIC->OleFunction( "AfficheDossierEnCours", 1);
      }catch(...){}// peut ne pas fonctionner en fonction de la version de Novaxel
    }

    if( Defaut_cap)
    {
      Defaut_cap->WriteBool( Defaut_cap_Section, Defaut_cap_ImpDef, false);
      Defaut_cap->UpdateFile( );
    }

    pvGedEIC->OleFunction( "FinCapture");
    pvGedEIC->OleFunction( "DebutCapture");
    GEDGlobal->bCapture = true;
/*    if( !pvGedEIC->OleFunction( "DebutCapture"))
    {
      EICErreur( "Erreur lors de l'enregistrement du document dans "NomAppliGED".\r\nVeuillez fermer "NomAppliGED" et rééssayer.");
      bReturn = false;
    }*/
    if( Defaut_cap)
    {
      Defaut_cap->WriteBool( Defaut_cap_Section, Defaut_cap_ImpDef, true);
      Defaut_cap->UpdateFile( );
    }
}
//---------------------------------------------------------------------------
bool __fastcall GED_DebutDocument(Variant *pvGedEIC, const WideString &Classement, int &DestGED, const AnsiString &NomDocument, AnsiString &NomImprimante)
{
  bool bReturn = true;
  bool bSeparation = true;
  bool criteresOk = true;
  bool bClassementAppliqueAuDocumentCourant = true;
  switch( GED_Envoi( pvGedEIC, Classement, NomDocument, DestGED, NomImprimante, bSeparation,bClassementAppliqueAuDocumentCourant,1,0,0))
  {
    case mrCancel : bReturn = false; break;
    case mrOk     : bReturn = true;  break;
    default       : ASSERT( false);
    case mrRetry  : {              
                    WideString ClassementSansChemise = Classement, ClassementAvecChemise,Chemise;
                    TStringList *Criteres = new TStringList();
                    Criteres->CommaText = Classement;
                    ClassementSansChemise = ClassementAvecChemise = Criteres->CommaText;
                    int iddossier = 0;
                    if ((int)pvGedEIC->OlePropertyGet("ColonneCount") !=  Criteres->Count)
                    {
                      //Le nb de critères diffère du nb de colonnes => on a une chemise
                      Chemise = Criteres->Strings[Criteres->Count-1];
                      Criteres->Delete(Criteres->Count-1);
                      ClassementSansChemise = Criteres->CommaText;
                    }
                    else
                      iddossier = pvGedEIC->OleFunction("FindDossier", ClassementAvecChemise);
                        if( iddossier <= 0 )
                        {
                          //Le dossier n' pas été trouvé, on essaie en enlevant le dernier critère (qui est peut être la chemise)
                          iddossier = pvGedEIC->OleFunction("FindDossier", ClassementSansChemise);
                        }
                        if( iddossier <= 0 )
                        {
                          int i;
                          WideString EmptyWtr = L"";
                          if( (int)pvGedEIC->OleFunction( "GetItems", WideString(Criteres->Strings[0]), EmptyWtr,EmptyWtr,EmptyWtr,EmptyWtr,EmptyWtr,EmptyWtr) == false)
                          {
                            EICAttention( "'" + Criteres->Strings[0] + "' n'existe pas en tant qu'armoire dans "NomAppliGED
                                          ". L'impression ne peut donc pas être classée.");

                          }
                          else
                          {
                            /*for (int i=0; i < Criteres->Count; i++)
                              if (Criteres->Strings[i].IsEmpty())
                              {
                                EICAttention( "L'un des critères de classement est vide.\nL'impression ne peut donc pas être classée.");
                                criteresOk = false;
                                break;
                              }    */
                            if( criteresOk && EICQuestion( AnsiString( "Le dossier ") + ClassementSansChemise + " n'existe pas. Voulez vous le créer ?", "Question"))
                            {
                              pvGedEIC->OleFunction( "CreerDossier", ClassementSansChemise);
                              iddossier = pvGedEIC->OleFunction( "FindDossier", ClassementSansChemise);
                            }
                          }
                        }
                        if( iddossier > 0)
                        {
                          pvGedEIC->OleFunction( "ChargeDossierNum", iddossier);
                          if( !Chemise.IsEmpty())
                            pvGedEIC->OleFunction( "TrouveChemise", /*Classement*/ClassementAvecChemise);
                        }else{
                            bReturn = false;
                        }
                      //}
                    //}
                    delete Criteres;
                    }
  }
  if( bReturn)
  {
    GED_Capture(pvGedEIC, DestGED);
  }
  return bReturn;

}
//---------------------------------------------------------------------------
bool __fastcall GED_FinDocument( Variant *pvGedEIC)
{
  try {
    pvGedEIC->OleFunction("FinCapture");
  }catch(...){ShowMessage("Impossible de désactiver la capture");}
  GEDGlobal->bCapture = false;
  return true;
}


//---------------------------------------------------------------------------
// Pour RHPAYE utiliser les Focntions exportees qui prennent des long& semble
// poser des problèmes. On crée donc deux fonctions qui encapsulent le pilotage.
// GED_Debut encapsule GED_Ouvre et GED_DebutDocument
// GED_Fin encapsule GED_FinDocument et GED_Ferme
Variant *g_pvGedEIC = NULL;
//----------------------------------------------------------------------------
extern "C" bool __stdcall GED_Debut(char *szNomImprimante, int nTaille)
{
  int nDestGED = 0;

  Debut:
  if(!IsProcessusEnCours(NomProcessusGED))  // pour savoir si novaxel est lancé j'ai refait une fonction car l'utilisation de pvGedEIC->OleFunction( "GetItemsOfBranche",.... plante dans la paye
  {
   // si on utilise la Dll depuis docucs, on la réactive quand il faut car elle a tendance à se cacher
    HWND hDoducs = FindWindow("TForm2", "Aperçu");
    if( !EICReessayer( "Veuillez lancer "NomAppliGED" avant d'envoyer un document.", "Attention..."))
    {
        if(hDoducs) BringWindowToTop(hDoducs);
        return false;
    }

    if(hDoducs) BringWindowToTop(hDoducs);

    goto Debut;
  }

  g_pvGedEIC = new Variant;
  if(!GED_Ouvre(g_pvGedEIC))
  {
      delete g_pvGedEIC;
      g_pvGedEIC = NULL;
      return false;
  }

  if(GED_DebutDocument((long)g_pvGedEIC, "", nDestGED, "", szNomImprimante, nTaille))
  {
    return true; // pour etre utilisable par RHPAYE, il faut retourner true ou false, pas la variable
  }
  else
  {
    return false; // pour etre utilisable par RHPAYE, il faut retourner true ou false, pas la variable
  }
}

extern "C" bool __stdcall GED_Fin()
{

    if(g_pvGedEIC)
    {
         GED_FinDocument(g_pvGedEIC);
        GED_Ferme(g_pvGedEIC);
        delete g_pvGedEIC;
        g_pvGedEIC = NULL;
    }
    return true;
}

extern "C" bool GEDAPI __stdcall GED_EstInstallee()
{
  return GED_IsInstallee();
}


bool IsProcessusEnCours(char *szNomProcessus)
{
  typedef HANDLE (*FnctCreateToolhelp32Snapshot)(DWORD dwFlags,DWORD th32ProcessID);
  typedef bool (*FnctProcess32First)(HANDLE hSnapshot,LPPROCESSENTRY32 lppe);
  typedef bool (*FnctProcess32Next)(HANDLE hSnapshot,LPPROCESSENTRY32 lppe);
  FnctCreateToolhelp32Snapshot fCreateToolhelp32Snapshot;
  FnctProcess32First fProcess32First;
  FnctProcess32Next fProcess32Next;
  HANDLE hProcessSnap;
  HANDLE hProcess;
  PROCESSENTRY32 pe32;
  DWORD dwPriorityClass;
  bool bTrouve = false;
  HINSTANCE hDll = NULL;

  hDll = ::GetModuleHandle("Kernel32.dll");
  if (!hDll)
    {
      EICErreur("Impossible de charger Kernel32.dll");
      return true;  //on fait comme si la GED était chargée
    }
  fCreateToolhelp32Snapshot = (FnctCreateToolhelp32Snapshot)::GetProcAddress(hDll,"CreateToolhelp32Snapshot");
  fProcess32First = (FnctProcess32First)::GetProcAddress(hDll,"Process32First");
  fProcess32Next = (FnctProcess32Next)::GetProcAddress(hDll,"Process32Next");
  if (!fCreateToolhelp32Snapshot || !fProcess32First || !fProcess32Next)
    {//On est peut-être sur NT4, les fonctions n'existent pas
      return true;  //on fait comme si la GED était chargée
    }
  // Take a snapshot of all processes in the system.
  hProcessSnap = fCreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
  if(hProcessSnap == INVALID_HANDLE_VALUE)
  {
    return false;
  }

  // Set the size of the structure before using it.
  pe32.dwSize = sizeof(PROCESSENTRY32);

  // Retrieve information about the first process, and exit if unsuccessful
  if(!fProcess32First( hProcessSnap, &pe32))
  {
    return false;
  }

  // il ne reste plus qu'a parcourir la liste des processus et voir si celui qu'on cherche est dedans
  do
  {
      bTrouve = !strcmp(strupr(pe32.szExeFile), strupr(szNomProcessus));
  } while(!bTrouve && fProcess32Next( hProcessSnap, &pe32));

  CloseHandle( hProcessSnap );
  return bTrouve;
}

bool __fastcall TrouveDossier(Variant *pvGedEIC, const AnsiString &pImage, AnsiString *pNomDocument, AnsiString *pArborescence)
{
  TStringList *Chemin = NULL;
  AnsiString  Chemise,Arborescence;
  int NbColonnes;
  bool Trouve = false;
  if( CreationObjetGED( pvGedEIC))
  {
    Chemin = new TStringList();
    Chemin->CommaText = pImage;
    if (Chemin->Count < 2)
      {
        EICAttention("Le chemin associé n'est pas valide.\nRécupération du document impossible.");
        delete Chemin;
        return false;
      }
    *pNomDocument = Chemin->Strings[Chemin->Count - 1];  //Le nom du document est le dernier du chemin
    Chemin->Delete(Chemin->Count - 1);  //On retire le nom du document du chemin
    Chemise = Chemin->Strings[Chemin->Count - 1];  //S'il ya une chemise elle est placée en dernier dans le chemin restant
    if (!Chemise.IsEmpty() && (Chemise[1] == '['))
      {//Il y a une chemise
        Chemise = Chemise.SubString(2,Chemise.Length() - 2);  //On retire les crochets
        Chemin->Delete(Chemin->Count - 1);  //On retire la chemise du chemin
      }
    else
      {//Il n'y a pas de chemise
        Chemise = EmptyStr;
      }
    for (int i = 0;i < Chemin->Count;i++)
      Arborescence = Arborescence + Chemin->Strings[i] + "/";
    Arborescence.Delete(Arborescence.Length(),1);
    *pArborescence = Arborescence;
    int numeroDossier = 0;
    numeroDossier = pvGedEIC->OleFunction("FindDossier",WideString(Chemin->CommaText));
    if (numeroDossier >0)
      {//On a trouvé le bon dossier
        //On commence par afficher le dossier en cours
        pvGedEIC->OleFunction("AfficheDossierEncours",true);
        //On charge le bon dossier
        if ((bool)pvGedEIC->OleFunction("ChargeDossierNum",numeroDossier))
        {
          //On a pu afficher le bon dossier
          if (!Chemise.IsEmpty())
            {//Il y a une chemise, on doit sélectionner la bonne chemise
              NbColonnes = (int)pvGedEIC->OlePropertyGet("ChemiseCount");
              for (int i = 0;i < NbColonnes;i++)
                if (AnsiSameText(Chemise,AnsiString(pvGedEIC->OlePropertyGet("TitreChemise",i))))
                  {
                    Trouve = true;
                    pvGedEIC->OlePropertySet("ActiveChemise",i);
                    return true;
                  }
              if (!Trouve)
                {
                  EICAttention(EICFormat("Impossible de trouver la chemise '%s'\ndans l'arborescence '%s'.\n\nVeillez à ce que la bonne bibliothèque soit ouverte.",Chemise.c_str(),Arborescence.c_str()));
                  return false;
                }
            }
          else
            return true;
        }
        else
        {
          EICAttention(EICFormat("Impossible d'afficher l'arborescence '%s'.",Arborescence.c_str()));
          return false;
        }
      }
    else
    {
      EICAttention(EICFormat("Impossible de trouver l'arborescence '%s'.\n\nVérifiez que la bonne bibliothèque soit ouverte.",Arborescence.c_str()));
      return false;
    }
  }
  return false;
}

/*Cette fonction crée un fichier sur le disque correspondant au fichier stocké dans GED'EIC*/
bool __fastcall GED_RecupererDocumentTmp(Variant *pvGedEIC,const AnsiString &pImage,const AnsiString &pRepDestination, AnsiString &pNomFichierExporte)
{
  int NbColonnes;
  bool Trouve = false;
  AnsiString NomDocument,Arborescence;
  OLEInitialize();
  try
    {
      if (TrouveDossier(pvGedEIC, pImage, &NomDocument,&Arborescence))
      {
        NbColonnes = (int)pvGedEIC->OlePropertyGet("PageCount");
        for (int i = 0;i < NbColonnes;i++)
        {
          if (AnsiSameText(NomDocument,AnsiString(pvGedEIC->OleFunction("FgetTitrePage",i))) /*&& (bool)pvGedEIC->OleFunction("AffichePage",i)*/)
            {//On a trouvé le bon document
              pvGedEIC->OleFunction("FsetSelectPage",i, true);
              Trouve = true;
            }
            else
            {
              pvGedEIC->OleFunction("FsetSelectPage",i, false);
            }
        }
        if (Trouve)
        {
             Trouve = pvGedEIC->OleFunction("ExportePages",WideString(IncludeTrailingBackslash(pRepDestination)));
            // Récupère le nom du fichier exporté
            if (Trouve)
            {
              TSearchRec infosFichier;

              if( FindFirst( IncludeTrailingBackslash(pRepDestination) + "*.*", faAnyFile, infosFichier)==0) {
                do {
                  if( infosFichier.Name[1]!='.') {
                    pNomFichierExporte = IncludeTrailingBackslash( pRepDestination) + infosFichier.Name;
                    break;
                  }
                } while( FindNext( infosFichier)==0);
              }
              FindClose( infosFichier);
            }
          return Trouve;
        }
        else
          {
            EICAttention(EICFormat("Impossible de trouver le document '%s'\ndans l'arborescence '%s'.",NomDocument.c_str(),Arborescence.c_str()));
            return false;
          }
      }
    }
  catch(...)
    {
      *pvGedEIC = Unassigned;
      EICReessayer("Veuillez lancer " NomAppliGED " pour trouver le document.","Attention...");
    }
  return false;
}

bool __fastcall  GED_EnregistrerDocument(Variant *pvGedEIC,const AnsiString &pImage,const AnsiString &pNomFichier)
{
  OLEInitialize();
  AnsiString nomFichier = ExtractFileName(pNomFichier), extension = ExtractFileExt(pNomFichier).LowerCase();
  int posExtension;
  int typeFichier;
  bool resultat = false;
  AnsiString nomDocument, arborescence;
  try
  {
    if (TrouveDossier(pvGedEIC, pImage,&nomDocument, &arborescence))
    {
      // Récupère le nom du document compris dans le classement GEDEIC
      TStrings *classementGEDEIC = new TStringList();
      classementGEDEIC->CommaText = pImage;
      nomFichier = classementGEDEIC->Strings[classementGEDEIC->Count-1];
      delete classementGEDEIC;

      // Supprime le document si celui-ci existe déjà dans le dossier
      for (int i = 0; i < (int)pvGedEIC->OlePropertyGet("PageCount"); i++)
      {
        pvGedEIC->OleFunction("FsetSelectPage",i,pvGedEIC->OleFunction("FGetTitrePage",i) == nomFichier);
      }
      pvGedEIC->OleFunction("SupprimePages");
      // Insère le document dans GED'EIC
      typeFichier = pvGedEIC->OleFunction("NovaType",WideString(extension));
      if (typeFichier == 7)
      {
        typeFichier = 12;
      }
      if (!pvGedEIC->OleFunction("AjoutePage",typeFichier, WideString( extension.Delete( 1, 1).UpperCase()), false, WideString( pNomFichier), WideString( nomFichier)))
        EICInformation("Impossible d'enregistrer le fichier dans GED'EIC");
      else
        resultat = true;
    }
  }
  catch (...)
  {
    *pvGedEIC = Unassigned;
    EICReessayer("Veuillez lancer " NomAppliGED " pour trouver le document.","Attention...");
  }
  return resultat;
}

TStringList* __fastcall  GED_GetArmoire(Variant *pvGedEIC)
{
    Variant v = NULL;
    TStringList* slListArmoire;
    try {
      OLEInitialize();
      bool bGED=false;
      bool bEicReessayer = true;
      do{
        try{
          if( CreationObjetGED( pvGedEIC))
          {
            slListArmoire = new TStringList();
            WideString EmptyWtr;
            v = pvGedEIC->OleFunction( "GetItemsOfBranche", EmptyWtr, EmptyWtr,EmptyWtr,EmptyWtr);
            bGED = true;
            for(int o = 1;o<=v.ArrayHighBound(1);o++)
                slListArmoire->Add(v.GetElement(o).operator AnsiString());
          }else break;
        }catch(...){
          *pvGedEIC = Unassigned;
          bGED = false;
          if (bEicReessayer)
              if (!EICReessayer("Veuillez lancer "NomAppliGED" avant d'envoyer un document.","Attention..."))
                break;
        }
      }while( !bGED);
    }catch(...) {}
    GED_FinDocument(pvGedEIC);
    GED_Ferme(pvGedEIC);
    return slListArmoire;
}
